package modelo.Nivel;

import modelo.Escenografia.*;
import modelo.Orientacion.Posicion;
import modelo.controlAereo.*;
import java.util.ArrayList;

public class AeroParque {

    private int velocidadDeAeronaves;
    private Escenario unEscenario;
    private TorreDeControl unaTorreDeControl;
    private IndustriaDeAeronaves industria;
    private ArrayList<Aeronave> aeronavesNuevas;

    public AeroParque(int velocidadMaxDeAviones, ArrayList<Pista> pistas){
	velocidadDeAeronaves = velocidadMaxDeAviones;
	unEscenario = new Escenario(793,529);
	unaTorreDeControl = new TorreDeControl();
	industria= new IndustriaDeAeronaves();
	aeronavesNuevas = new ArrayList<Aeronave>();
	int i;
        for(i=0; i<pistas.size(); i++){
            Pista pista= pistas.get(i);
            unEscenario.agregarPistas(pista);
        }
    }

    public void actualizar(){
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: los aviones se mueven, chocan y aterrizan segun corresponda, al igual que se incrementa el tiempo*/
	unaTorreDeControl.avanzarAviones(unEscenario);
    }

    public boolean chocaronAeronaves(){
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: devuelve true si algun avion choco, o sea el nivel se perdio, en caso contrario devuelve false*/
	return this.unaTorreDeControl.algunAvionChoco();
    }

    public void agregarTrayectoriaAAeronaveEnPosicion(Posicion unaPosicion, Posicion unaTrayectoria) {
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: si en la posicion pasa hay un avion y la posicion de la trayectoria esta dentor del escenario
      entonces le agrega una trayectoria, en caso contrario no pasa nada*/
	if ((unEscenario.verificarPosicion(unaPosicion)) && (unEscenario.verificarPosicion(unaTrayectoria))){
		unaTorreDeControl.agregarTrayectoriaAAeronaveEnPosicion(unaPosicion, unaTrayectoria);
	}
    }

    public void agregarUnaNuevaAeronave(){
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: devuelve una aeronave que creo la industria*/
            Aeronave aeronave = industria.crearUnaAeronave(unEscenario, velocidadDeAeronaves);
            unaTorreDeControl.agregarAeronave(aeronave);
            aeronavesNuevas.add(aeronave);
    }

    public ArrayList<Aeronave> obtenerLasAeronaves(){
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: devuelve las aeronaves que estan en el nivel*/
            return unaTorreDeControl.obtenerAviones();
    }

    public ArrayList<Pista> obtenerLasPistas(){
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: devuelve las pistas que estan en el nivel*/
        return unEscenario.obtenerPistas();
    }

    public int devolverCantidadDeAvionesAterrizados(){
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: devuelve la cantidad de aviones aterrizados*/
        return unaTorreDeControl.devolverCantidadDeAvionesAterrizados();
    }
    
    public Escenario devolverEscenario(){
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: devuelve el escenario del aeroparque*/
    	return unEscenario;
    }

    public ArrayList<Aeronave> obtenerAeronavesNuevas() {
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: devuelve las aeronaves que se crearon nuevas*/
        return aeronavesNuevas;
    }
	
    public void eliminarAeronavesNuevas() {
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: elimina las aeronaves nuevas*/
	aeronavesNuevas.clear();
    }

    public ArrayList<Aeronave> devolverAeronavesChocadas() {
    /*PreCondicion: el aeroparque debe estar creado
      PostCondicion: devuelve las aeronaves chocadas*/
	return unaTorreDeControl.devolverAeronavesChocadas();
    }

    public ArrayList<Aeronave> devolverAeronavesAterrizadas(){
    /*PreCondicion: el aeroparque de control debe estar creada
      PostCondicion: devuelve una lista con las aeronaves aterrizadas*/
	return unaTorreDeControl.devolverAeronavesAterrizadas();
    }

    public void eliminarAeronavesAterrizadas(){
    /*PreCondicion: la torre de control debe estar creada
      PostCondicion: elimina las aeronaves aterrizadas del aeropuerto*/
	unaTorreDeControl.eliminarAeronavesAterrizadas();
    }

    public void eliminarAeronavesChocadas(){
    /*PreCondicion: la torre de control debe estar creada
      PostCondicion: elimina las aeronaves chocadas del aeropuerto*/
	unaTorreDeControl.eliminarAeronavesChocadas();
    }

}
